package com.mmall.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.google.common.collect.Lists;
import com.mmall.common.Const;
import com.mmall.common.ResponseCode;
import com.mmall.common.ServerResponse;
import com.mmall.dao.CategoryMapper;
import com.mmall.dao.ProductMapper;
import com.mmall.pojo.Category;
import com.mmall.pojo.Product;
import com.mmall.service.ICategroyService;
import com.mmall.service.IProductService;
import com.mmall.util.DateTimeUtil;
import com.mmall.util.PropertiesUtil;
import com.mmall.vo.ProductDetailVo;
import com.mmall.vo.ProductListVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;


@Service("iProductService")
public class ProductServiceImpl implements IProductService{

    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private ICategroyService iCategroyService;

    @Override
    public ServerResponse insterAndupdateAndProduct(Product product) {

        //1.判断product的信息,有信息,就进行下面的操作
        if (product != null){
            //2.判断图片是否为空
            if (StringUtils.isNotBlank(product.getSubImages())){
                //2.1不为空就截取第一张图片
                String[] split = product.getSubImages().split(",");
                //2.2然后把第一张图片放到前面,为首图大图
                product.setSubImages(split[0]);
            }
            //3.判断id是否存在,这样才能知道是在更新还是新增
            if (product.getId() != null){
                int productCount = productMapper.updateByPrimaryKey(product);
                if (productCount>0){
                    return  ServerResponse.createBySuccessMessage("更新商品成功");
                }
                return  ServerResponse.createByErrorMessage("更新商品失败");
            }else {
                int productCount = productMapper.insert(product);
                if (productCount>0){
                    return  ServerResponse.createBySuccessMessage("新增商品成功");
                }
                return  ServerResponse.createByErrorMessage("新增商品失败");
            }
        }

        return ServerResponse.createByErrorMessage("更新或者新增参数不正确,失败操作");
    }

    @Override
    public ServerResponse updateStatus(Integer productId, Integer status) {

        //判断id和状态的情况
        if (productId == null && status == null){
            //如果其中一个为空就直接返回结参数不正确
            return  ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(), ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }

        Product product = new Product();
        product.setId(productId);
        product.setStatus(status);

        int productCount = productMapper.updateByPrimaryKeySelective(product);

        if (productCount>0){
            return  ServerResponse.createBySuccessMessage("更新产品的销售状态成功");
        }
        return  ServerResponse.createBySuccessMessage("更新产品的销售状态失败");
    }

    @Override
    public ServerResponse getDetail(Integer productId) {
        //传过来的id不正确直接不能查找,可以直接返回参数错误等信息
        if (productId == null){
            //如果其中一个为空就直接返回结参数不正确
            return  ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(), ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        //查看产品的部分详情
        Product product = productMapper.selectByPrimaryKey(productId);
        if (product == null){
            return  ServerResponse.createByErrorMessage("查看产品详情失败");
        }
        //组装详情信息
        ProductDetailVo productDetailVo = assembleProductDetailVo(product);
        return ServerResponse.createBySuccess(productDetailVo);
    }

    //用来产品的分页
    @Override
    public ServerResponse<PageInfo> getList(Integer pageName, Integer pageSize) {

        //初始化产品的排序
        PageHelper.startPage(pageName,pageSize );

        //获得所以的分页结果集合,降序
       List<Product> productList = productMapper.selectList();

       //新建的集合类,用来存放组装好的分页数据
        ArrayList<ProductListVo> arrayList = Lists.newArrayList();

            //结果排序
        for (Product product : productList) {
               //获得组装数据
            ProductListVo productListVo = assembleProductListVo(product);
            //把组装好的结果放到集合里面
            arrayList.add(productListVo);
        }
        //把查询数据集合放到分页类中进行结果的处理
        PageInfo resultInfo = new PageInfo(productList);

        //最后设置一个组装的数据集合
        resultInfo.setList(arrayList);

        return ServerResponse.createBySuccess(resultInfo);
    }

    @Override
    public ServerResponse searchProduct(String productName, Integer productId, Integer pageName, Integer pageSize) {
        //分页初始化排序
        PageHelper.startPage(pageName,pageSize );

        if (StringUtils.isNotBlank(productName)){
            productName = new StringBuilder().append("%").append(productName).append("%").toString();

        }
        //用来根据搜索条件查询
        List<Product> productList = productMapper.searchProduct(productName,productId);

        //新建的集合类,用来存放组装好的分页数据
        ArrayList<ProductListVo> arrayList = Lists.newArrayList();

        //结果排序
        for (Product product : productList) {
            //获得组装数据
            ProductListVo productListVo = assembleProductListVo(product);
            //把组装好的结果放到集合里面
            arrayList.add(productListVo);
        }
        //把查询数据集合放到分页类中进行结果的处理
        PageInfo resultInfo = new PageInfo(productList);

        //最后设置一个组装的数据集合
        resultInfo.setList(arrayList);

        return ServerResponse.createBySuccess(resultInfo);
    }




    //用来组装分页的数据
    private ProductListVo assembleProductListVo(Product product){
        ProductListVo productListVo = new ProductListVo();
        productListVo.setId(product.getId());
        productListVo.setCategoryId(product.getCategoryId());
        productListVo.setName(product.getName());
        productListVo.setStatus(product.getStatus());
        productListVo.setMainImage(product.getMainImage());
        productListVo.setSubtitle(product.getSubtitle());
        productListVo.setPrice(product.getPrice());
        productListVo.setImageHost(PropertiesUtil.getProperty("http://img.happymmall.com/", "http://img.happymmall.com/"));
        return  productListVo;
    }


    //用来组装封装数据信息
    private ProductDetailVo assembleProductDetailVo(Product product){

        ProductDetailVo productDetailVo = new ProductDetailVo();

        productDetailVo.setId(product.getId());
        productDetailVo.setCategoryId(product.getCategoryId());
        productDetailVo.setName(product.getName());
        productDetailVo.setSubtitle(product.getSubtitle());
        productDetailVo.setMainImage(product.getMainImage());
        productDetailVo.setDetail(product.getDetail());
        productDetailVo.setPrice(product.getPrice());
        productDetailVo.setStock(product.getStock());
        productDetailVo.setStatus(product.getStatus());

        //查找根节点
        Category category = categoryMapper.selectByPrimaryKey(product.getCategoryId());
        if (category == null){
            //根节点没有直接赋值0
            productDetailVo.setParentCategoryId(0);
        }else {
            //根节点有直接赋值
            productDetailVo.setParentCategoryId(category.getParentId());
        }
        productDetailVo.setCreateTime(DateTimeUtil.dateToDate(product.getCreateTime()));
        productDetailVo.setUpdateTime(DateTimeUtil.dateToDate(product.getUpdateTime()));
        productDetailVo.setImageHost(PropertiesUtil.getProperty("http://img.happymmall.com/", "http://img.happymmall.com/"));
        return  productDetailVo;
    }



    //前端商品详情
    @Override
    public ServerResponse<ProductDetailVo> Detail(Integer productId) {
        //判断id这个值是否存在
        if (productId == null){
            return  ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc() );
        }
        //获得指定id对象
        Product product = productMapper.selectByPrimaryKey(productId);
        if (product == null){
            return  ServerResponse.createByErrorMessage("产品已销售完或产品已下架");
        }
        if (product.getStatus() != Const.ProductStatusEnum.ON_SALE.getCode()){
            return  ServerResponse.createByErrorMessage("产品已销售完或产品已下架");
        }
        ProductDetailVo productDetailVo = assembleProductDetailVo(product);
        return ServerResponse.createBySuccess(productDetailVo);
    }



    @Override
    public ServerResponse<PageInfo> List(String orderBy,Integer pageName, Integer pageSize, String productName, Integer categoryId) {

      //1.判断搜索关键字是否存在
        if (StringUtils.isBlank(productName) && categoryId == null){
            return  ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }

        //2.自定义一个集合用来存放,查询id的结果
        List<Integer> productIds = new ArrayList<Integer>();
        if (categoryId != null){
            //获得查询id得到是商品信息
            Category category = categoryMapper.selectByPrimaryKey(categoryId);
            //判断搜索条件都没有的情况下,返回空集合,不返回错误信息
            if (category == null && StringUtils.isBlank(productName)){
                //进行排序
                PageHelper.startPage(pageName,pageSize );
                ArrayList<ProductListVo> productListVo = Lists.newArrayList();
                PageInfo pageInfo = new PageInfo(productListVo);
                return ServerResponse.createBySuccess(pageInfo);
            }
            //查找到的id放到一开始创建的集合里面,进行递归查询出来
            productIds = iCategroyService.selectRecursionAndParentIdAndCategroy(category.getId()).getData();
        }
        //判断搜索有关键字的时候
        if (StringUtils.isNotBlank(productName)){
            //进行拼接成模糊查询
            productName = new StringBuilder().append("%").append(productName).append("%").toString();
        }

        //进行分页处理
        PageHelper.startPage(pageName,pageSize );

        //判断排序的情况
        if (StringUtils.isNotBlank(orderBy)){
           if (Const.ProductListOrderBy.PRICE_ASC_DESC.contains(orderBy)){
               String[] split = orderBy.split("_");
               PageHelper.orderBy(split[0]+" "+split[1]);
           }
        }

        //根据搜索的产品名称,和id查询,而且都进行了三元判断,并且id都是list集合,表示多个
       List<Product> productList = productMapper.selectAndproductNameAndproductId(StringUtils.isBlank(productName)? null:productName,productIds.size() == 0 ? null:productIds);

        //创建一个集合用来装组装的信息
        ArrayList<ProductListVo> productListVoList = Lists.newArrayList();
        //循环查询得到的结果
            for (Product product : productList) {
                //然后进行组装
                ProductListVo productListVo = assembleProductListVo(product);
                productListVoList.add(productListVo);

        }
        //查询等到的所有结果放到分页里面进行分页
        PageInfo pageInfo = new PageInfo(productList);
        //最后指定增加组装的信息
        pageInfo.setList(productListVoList);

        return ServerResponse.createBySuccess(pageInfo);
    }


}
